Scope

Undocumented

Undocumented

Undocumented

Undocumented

Finalize returns the Graph on which this scope operates on and renders s unusable. If there was an error during graph construction, that error is returned instead.

AddOperation adds the operation to the Graph managed by s.

If there is a name prefix associated with s (such as if s was created by a call to SubScope), then this prefix will be applied to the name of the operation being added. See also Graph.AddOperation.

SubScope returns a new Scope which will cause all operations added to the graph to be namespaced with ‘namespace’. If namespace collides with an existing namespace within the scope, then a suffix will be added.

Undocumented

Undocumented

Undocumented

Adds operations to compute the partial derivatives of sum of ys w.r.t xs, i.e., d(y_1 + y_2 + …)/dx_1, d(y_1 + y_2 + …)/dx_2… dx are used as initial gradients (which represent the symbolic partial derivatives of some loss function L w.r.t. y). dx must be nullptr or have size ny. If dx is nullptr, the implementation will use dx of OnesLike for all shapes in y. The partial derivatives are returned in dy. dy should be allocated to size nx.

WARNING: This function does not yet support all the gradients that python supports. See https://www.tensorflow.org/code/tensorflow/cc/gradients/README.md for instructions on how to add C++ more gradients.

Undocumented

Does nothing. Only useful as a placeholder for control edges.

Computes the gradient function for function f via backpropagation.

The function ‘f’ must be a numerical function which takes N inputs and produces M outputs. Its gradient function ‘g’, which is computed by this SymbolicGradient op is a function taking N + M inputs and produces N outputs.

I.e. if we have (y1, y2, …, y_M) = f(x1, x2, …, x_N), then, g is (dL/dx1, dL/dx2, …, dL/dx_N) = g(x1, x2, …, x_N, dL/dy1, dL/dy2, …, dL/dy_M),

where L is a scalar-value function of (x1, x2, …, xN) (e.g., the loss function). dL/dx_i is the partial derivative of L with respect to x_i.

(Needs some math expert to say the comment above better.)

Converts an array of tensors to a list of tensors.

Converts a list of tensors to an array of tensors.

A graph node which represents a return value of a function.

A graph node which represents an argument to a function.

Quantized Batch normalization. This op is deprecated and will be removed in the future. Prefer tf.nn.batch_normalization.

Computes Quantized Rectified Linear 6: min(max(features, 0), 6)

Computes gradient of the FractionalMaxPool function.

index 0 1 2 3 4

value 20 5 16 3 7

If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice. The result would be [20, 16] for fractional max pooling.

Says whether the targets are in the top K predictions. This outputs a batch_size bool array, an entry out[i] is true if the prediction for the target class is among the top k predictions among all predictions for example i. Note that the behavior of InTopK differs from the TopK op in its handling of ties; if multiple classes have the same prediction value and straddle the top-k boundary, all of those classes are considered to be in the top k.

More formally, let

\(predictions_i\) be the predictions for all classes for example i, \(targets_i\) be the target class for example i, \(out_i\) be the output for example i,

$$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$

Computes softmax cross entropy cost and gradients to backpropagate. Inputs are the logits, not probabilities.

Computes log softmax activations. For each batch i and class j we have

 logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))

Computes softsign gradients for a softsign operation.

Computes softplus: log(exp(features) + 1).

Computes gradients for the exponential linear (Elu) operation.

Computes exponential linear: exp(features) - 1 if < 0, features otherwise. See Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)

Computes rectified linear 6: min(max(features, 0), 6).

Computes rectified linear gradients for a Relu operation.

Computes the gradient of morphological 2-D dilation with respect to the input.

Sends the named tensor from send_device to recv_device.

Computes second-order gradients of the maxpooling function.

Computes second-order gradients of the maxpooling function.

Computes gradients of the maxpooling function.

Computes gradients of the maxpooling function.

Performs max pooling on the input.

Gradients for Local Response Normalization.

Receives the named tensor from send_device on recv_device. _HostRecv requires its input on host memory whereas _Recv requires its input on device memory.

Computes second-order gradients of the maxpooling function.

Computes the gradients of 3-D convolution with respect to the filter.

Computes a 3-D convolution given 5-D input and filter tensors. In signal processing, cross-correlation is a measure of similarity of two waveforms as a function of a time-lag applied to one of them. This is also known as a sliding dot product or sliding inner-product.

Our Conv3D implements a form of cross-correlation.

Computes the gradients of depthwise convolution with respect to the filter.

Computes the gradients of convolution with respect to the filter.

Computes the gradients of convolution with respect to the input.

Adds bias to value. This is a special case of tf.add where bias is restricted to be 1-D. Broadcasting is supported, so value may have any number of dimensions.

Batch normalization. Note that the size of 4D Tensors are defined by either NHWC or NCHW. The size of 1D Tensors matches the dimension C of the 4D Tensors.

Batch normalization. Note that the size of 4D Tensors are defined by either NHWC or NCHW. The size of 1D Tensors matches the dimension C of the 4D Tensors.

Given a quantized tensor described by (input, input_min, input_max), outputs a range that covers the actual values present in that tensor. This op is typically used to produce the requested_output_min and requested_output_max for Requantize.

Convert the quantized ‘input’ tensor into a lower-precision ‘output’, using the actual distribution of the values to maximize the usage of the lower bit depth and adjusting the output min and max ranges accordingly.

[input_min, input_max] are scalar floats that specify the range for the float interpretation of the ‘input’ data. For example, if input_min is -1.0f and input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0 value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.

This operator tries to squeeze as much precision as possible into an output with a lower bit depth by calculating the actual min and max values found in the data. For example, maybe that quint16 input has no values lower than 16,384 and none higher than 49,152. That means only half the range is actually needed, all the float interpretations are between -0.5f and 0.5f, so if we want to compress the data into a quint8 output, we can use that range rather than the theoretical -1.0f to 1.0f that is suggested by the input min and max.

In practice, this is most useful for taking output from operations like QuantizedMatMul that can produce higher bit-depth outputs than their inputs and may have large potential output ranges, but in practice have a distribution of input values that only uses a small fraction of the possible range. By feeding that output into this operator, we can reduce it from 32 bits down to 8 with minimal loss of accuracy.

Perform a quantized matrix multiplication of a by the matrix b. The inputs must be two-dimensional matrices and the inner dimension of a (after being transposed if transpose_a is non-zero) must match the outer dimension of b (after being transposed if transposed_b is non-zero).

Compute the cumulative sum of the tensor x along axis. By default, this op performs an inclusive cumsum, which means that the first element of the input is identical to the first element of the output:

 tf.cumsum([a, b, c])  # => [a, a + b, a + b + c]

By setting the exclusive kwarg to True, an exclusive cumsum is performed instead:

 tf.cumsum([a, b, c], exclusive=True)  # => [0, a, a + b]

By setting the reverse kwarg to True, the cumsum is performed in the opposite direction:

 tf.cumsum([a, b, c], reverse=True)  # => [a + b + c, b + c, c]

This is more efficient than using separate tf.reverse ops.

The reverse and exclusive kwargs can also be combined:

 tf.cumsum([a, b, c], exclusive=True, reverse=True)  # => [b + c, c, 0]

Gradients for batch normalization. This op is deprecated. See tf.nn.batch_normalization.

Counts the number of occurrences of each value in an integer array. Outputs a vector with length size and the same dtype as weights. If weights are empty, then index i stores the number of times the value i is counted in arr. If weights are non-empty, then index i stores the sum of the value in weights at each index where the corresponding value in arr is i.

Values in arr outside of the range [0, size) are ignored.

Compute the pairwise cross product. a and b must be the same shape; they can either be simple 3-element vectors, or any shape where the innermost dimension is 3. In the latter case, each pair of corresponding 3-element vectors is cross-multiplied independently.

Returns the complex conjugate of a complex number. Given a tensor input of complex numbers, this operation returns a tensor of complex numbers that are the complex conjugate of each element in input. The complex numbers in input must be of the form \(a + bj\), where * a * is the real part and * b * is the imaginary part.

The complex conjugate returned by this operation is of the form \(a - bj\).

For example:

 # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
 tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]

Returns the real part of a complex number. Given a tensor input of complex numbers, this operation returns a tensor of type float that is the real part of each element in input. All elements in input must be complex numbers of the form \(a + bj\), where * a * is the real part returned by this operation and * b * is the imaginary part.

For example:

 # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
 tf.real(input) ==> [-2.25, 3.25]

Converts two real numbers to a complex number. Given a tensor real representing the real part of a complex number, and a tensor imag representing the imaginary part of a complex number, this operation returns complex numbers elementwise of the form \(a + bj\), where

• a * represents the real part and * b * represents the imag part.

The input tensors real and imag must have the same shape.

For example:

 # tensor 'real' is [2.25, 3.25]
 # tensor `imag` is [4.75, 5.75]
 tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]

Computes the logical or of elements across dimensions of a tensor. Reduces input along the dimensions given in reduction_indices. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in reduction_indices. If keep_dims is true, the reduced dimensions are retained with length 1.

Computes the mean along sparse segments of a tensor. Read @{$math_ops#segmentation$the section on segmentation} for an explanation of segments.

Like SegmentMean, but segment_ids can have rank less than data‘s first dimension, selecting a subset of dimension 0, specified by indices.

Computes the sum along segments of a tensor. Read @{$math_ops#segmentation$the section on segmentation} for an explanation of segments.

Computes a tensor such that (output[i] = sum_{j...} data[j...] where the sum is over tuples j... such that segment_ids[j...] == i. Unlike SegmentSum, segment_ids need not be sorted and need not cover all values in the full range of valid values.

If the sum is empty for a given segment ID i, output[i] = 0.

num_segments should equal the number of distinct segment IDs.

Computes the product along segments of a tensor. Read @{$math_ops#segmentation$the section on segmentation} for an explanation of segments.

Computes a tensor such that \(output_i = \prod_j data_j\) where the product is over j such that segment_ids[j] == i.

If the product is empty for a given segment ID i, output[i] = 1.

Computes the maximum of elements across dimensions of a tensor. Reduces input along the dimensions given in reduction_indices. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in reduction_indices. If keep_dims is true, the reduced dimensions are retained with length 1.

Computes the minimum of elements across dimensions of a tensor. Reduces input along the dimensions given in reduction_indices. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in reduction_indices. If keep_dims is true, the reduced dimensions are retained with length 1.

Computes the product of elements across dimensions of a tensor. Reduces input along the dimensions given in reduction_indices. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in reduction_indices. If keep_dims is true, the reduced dimensions are retained with length 1.

Computes the sum of elements across dimensions of a tensor. Reduces input along the dimensions given in reduction_indices. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in reduction_indices. If keep_dims is true, the reduced dimensions are retained with length 1.

Computes gradients for the scaled exponential linear (Selu) operation.

Multiply matrix a by matrix b. The inputs must be two-dimensional matrices and the inner dimension of a must match the outer dimension of b. This op is optimized for the case where at least one of a or b is sparse. The breakeven for using this versus a dense matrix multiply on one platform was 30% zero values in the sparse matrix.

The gradient computation of this operation will only take advantage of sparsity in the input gradient when that gradient comes from a Relu.

Multiply the matrix a by the matrix b. The inputs must be two-dimensional matrices and the inner dimension of a (after being transposed if transpose_a is true) must match the outer dimension of b (after being transposed if transposed_b is true).

Returns the truth value of x AND y element-wise.

Returns the truth value of abs(x-y) < tolerance element-wise.

Returns the truth value of (x >= y) element-wise.

Returns the truth value of (x <= y) element-wise.

Compute the polygamma function \(\psi// ^{(n)}(x)\). The polygamma function is defined as:

\(\psi// ^{(n)}(x) = \frac{d// ^n}{dx// ^n} \psi(x)\)

where \(\psi(x)\) is the digamma function.

Compute the lower regularized incomplete Gamma function Q(a, x). The lower regularized incomplete Gamma function is defined as:

\(P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)\)

where

\(gamma(a, x) = int_{0}// ^{x} t// ^{a-1} exp(-t) dt\)

is the lower incomplete Gamma function.

Note, above Q(a, x) (Igammac) is the upper regularized complete Gamma function.

Compute the upper regularized incomplete Gamma function Q(a, x). The upper regularized incomplete Gamma function is defined as:

\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\)

where

\(Gamma(a, x) = int_{x}// ^{\infty} t// ^{a-1} exp(-t) dt\)

is the upper incomplete Gama function.

Note, above P(a, x) (Igamma) is the lower regularized complete Gamma function.

Returns element-wise remainder of division. This emulates C semantics in that the result here is consistent with a truncating divide. E.g. truncate(x / y) * y + truncate_mod(x, y) = x.

Returns the max of x and y (i.e. x > y ? x : y) element-wise.

Returns (x - y)(x - y) element-wise.

Returns (x - y)(x - y) element-wise.

Returns x / y element-wise for real types. If x and y are reals, this will return the floating-point division.

Returns x / y element-wise for integer types. Truncation designates that negative numbers will round fractional quantities toward zero. I.e. -7 / 5 = 1. This matches C semantics but it is different than Python semantics. See FloorDiv for a division function that matches Python Semantics.

Returns x * y element-wise.

Returns x + y element-wise.

Returns element-wise smallest integer in not less than x.

Returns which elements of x are finite. @compatibility(numpy) Equivalent to np.isfinite @end_compatibility

Performs 3D max pooling on the input.

Returns which elements of x are Inf. @compatibility(numpy) Equivalent to np.isinf @end_compatibility

Finds values and indices of the k largest elements for the last dimension. If the input is a vector (rank-1), finds the k largest entries in the vector and outputs their values and indices as vectors. Thus values[j] is the j-th largest entry in input, and its index is indices[j].

For matrices (resp. higher rank input), computes the top k entries in each row (resp. vector along the last dimension). Thus,

 values.shape = indices.shape = input.shape[:-1] + [k]

If two elements are equal, the lower-index element appears first.

Computes cos of x element-wise.

Computes sin of x element-wise.

Computes the gradient of the sigmoid of x wrt its input. Specifically, grad = dy * y * (1 - y), where y = sigmoid(x), and dy is the corresponding input gradient.